Internet Info 1994 March

home *** CD-ROM | disk | FTP | other *** search

/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / c / ccster.asm < prev next >

Wrap

Assembly Source File | 1991-09-07 | 33.2 KB | 785 lines

NAME ccster ; File CCSTER.ASM ;CHINESE ifdef MSDOS include msster.dat else include ccster.dat endif code segment public 'code' extrn comnd:near, outchr:near, stat0:near, iseof:near extrn clrbuf:near, term:near, strlen:near extrn prtchr:near, ihostr:near extrn beep:near, puthlp:near, getbaud:near, serhng:near extrn serini:near,serrst:near, sendbr:near, showkey:near extrn fpush:near, dumpscr:near, pcwait:near, sendbl:near assume cs:code, ds:datas ; the show key command shokey proc near cmp shkadr,0 ; keyboard translator present? je shokey1 ; e = no, use regular routines mov bx,shkadr ; get offset of replacement routine jmp bx ; and execute it rather than us shokey1:jmp rskp ; and return shokey endp ; enter with ax/scan code to define, si/ pointer to definition, cx/ length ; of definition. Defines it in definition table. Obsolete. defkey proc near ret defkey endp ; This is the CONNECT command TELNET PROC NEAR mov ah,cmcfm call comnd ; Get a confirm jmp r ; Didn't get a confirm mov ah,prstr ; Output mov dx,offset crlf ; a crlf int dos cmp flags.vtflg,0 ; emulating a terminal? jne teln1 ; ne= yes, skip flashing message call domsg ; Reassure user teln1: call serini ; ensure port is inited now mov al,0 ; initial flags mov ttyact,1 ; say telnet is active cmp flags.modflg,0 ; mode line enabled? jne tel010 ; ne = yes or al,modoff ; no, make sure it stays off tel010: or al,havtt ; defaults (!) test flags.debug,logses ; debug mode? jz tel0 ; z = no, keep going or al,trnctl ; yes, show control chars tel0: cmp flags.vtflg,0 ; emulating a terminal? je tel1 ; e = no or al,emheath ; say emulating some kind of terminal tel1: mov bx,portval cmp [bx].ecoflg,0 ; echoing? jz tel2 or al,lclecho tel2: call getbaud ; pickup current baud rate for port mov targ.flgs,al ; store flags mov ah,flags.comflg ; COMs port identifier mov targ.prt,ah ; Port 1 or 2, etc mov ah,trans.escchr ; escape character mov targ.escc,ah mov ah,[bx].parflg ; parity flag mov targ.parity,ah mov ax,[bx].baud ; baud rate identifier mov targ.baudb,al xor ah,ah test flags.capflg,logses ; select session logging flag bit jz tel3 ; z = no logging mov ah,capt ; set capture flag tel3: or targ.flgs,ah TEM: call serini ; init serial port jnc tem0 ; nc = success mov ttyact,0 ; say we are no longer active jmp rskp ; and exit Connect mode tem0: mov dx,offset crlf ; give user an indication that we are mov ah,prstr ; entering terminal mode int dos mov ax,offset targ ; Point to terminal arguments call term ; Call the main Terminal procedure or targ.flgs,scrsam ; assume screen is the same tem1: mov al,kbdflg ; get the char from Term, if any mov kbdflg,0 ; clear the flag cmp al,0 ; was there a char from Term? jne intch2 ; ne = yes, else ask for one from kbd intchar:call iseof ; stdin at eof? jnc intch1 ; nc = not eof, get more mov al,'C' ; use C when file is empty jmp intchc ; to provide an exit intch1: mov ah,coninq ; read keyboard, no echo int dos ; get a char cmp al,0 ; scan code indicator? jne intch2 ; ne = no, ascii mov ah,coninq ; read and discard scan code int dos jmp short intch1 ; try again intch2: cmp al,' ' ; space? je tem ; e = yes, ignore it cmp al,cr ; check ^M (cr) against plain ascii M je tem ; exit on cr cmp al,trans.escchr ; Is it the escape char? jne intch3 ; ne = no mov ah,al call outchr nop nop nop jmp tem ; Return, we are done here intch3: push es push ds pop es mov di,offset intclet ; command letters mov cx,numlet ; quantity of them cmp al,' ' ; control code? jae intch3a ; ae = no or al,40H ; convert control chars to printable intch3a:cmp al,96 ; lower case? jb intch3b ; b = no and al,not (20h) ; move to upper case intch3b:cld repne scasb ; find the matching letter pop es jne intch4 ; ne = not found, beep and get another dec di ; back up to letter sub di,offset intclet ; get letter number shl di,1 ; make it a word index jmp intcjmp[di] ; dispatch to it intch4: call beep ; say illegal character jmp intchar intchb: call sendbr ; 'B' send a break jmp tem ; And return intchc: mov ttyact,0 ; 'C' say we are no longer active jmp rskp ; and exit Connect mode intchf: call dumpscr ; 'F' dump screen, use msy routine jmp tem ; and return intchh: call serhng ; 'H' hangup phone call serrst ; turn off port jmp tem intchl: call sendbl ; 'L' send a long break jmp tem intchm: cmp flags.modflg,1 ; 'M' toggle mode line, enabled? jne intchma ; ne = no, leave it alone xor targ.flgs,modoff ; enabled, toggle its state intchma:jmp tem ; and reconnect intchp: push bx ; 'P' push to DOS mov bx,portval mov ah,byte ptr [bx].flowc ; get XOFF char, or null pop bx or ah,ah ; check for null (no flow control) jz intchpa ; z = null, don't send one call outchr ; send XOFF to host while we are away nop nop nop intchpa:call serrst ; turn off serial interrupts call fpush ; try pushing nop nop nop ; mov dx,offset sttmsg ; say we have returned mcmsg sttmsg,csttmsg mov ah,prstr int dos call serini ; init serial port again jc intchc ; nc = failure call ihostr ; XON the host (if using flow control) jmp intchsb ; wait for a space intchq: test targ.flgs,capt ; 'Q' suspend logging. Logging active? jz intchq1 ; z = no and targ.flgs,not capt ; stop capturing intchq1:jmp tem ; and resume intchr: test flags.capflg,logses ; 'R' resume logging. Can we capture? jz intchr1 ; z = no test targ.flgs,capt ; already capturing? jnz intchr1 ; yes, can't toggle back on then or targ.flgs,capt ; else turn flag on intchr1:jmp tem ; and resume intchs: call stat0 ; 'S' status, call stat0 call puthlp ; put help on screen ; mov dx,offset sttmsg mcmsg sttmsg,csttmsg mov ah,prstr int dos intchsa:call iseof ; is stdin at eof? jnc intchsb ; nc = not eof, get more jmp tem ; resume if EOF intchsb:mov ah,coninq ; console input, no echo int dos cmp al,' ' ; space? jne intchsa and targ.flgs,not scrsam ; remember screen changed jmp tem intchu: ;------------------- Sept 21,1990 [zqf] ; mov ax,offset inthlp ; '?' get help message push dx mcmsg inthlp,cinthlp mov ax,dx pop dx ;------------------- call puthlp ; write help msg ; mov dx,offset intprm mcmsg intprm,cintprm mov ah,prstr ; Print it int dos and targ.flgs,not scrsam ; remember screen changed jmp intchar ; Get another char intchn: mov ah,0 ; '0' send a null call outchr nop nop nop jmp tem TELNET ENDP ; Reassure user about connection to the host. Tell him what escape sequence ; to use to return and the communications port and baud; rate being used DOMSG PROC NEAR mov ah,prstr ; mov dx,offset tmsg1 mcmsg tmsg1,ctmsg1 int dos call escprt mov ah,prstr ; mov dx,offset tmsg3 mcmsg tmsg3,ctmsg3 int dos ret DOMSG ENDP ; print the escape character in readable format. ESCPRT PROC NEAR mov dl,trans.escchr cmp dl,' ' jge escpr2 push dx mov ah,prstr mov dx,offset esctl int dos pop dx add dl,040H ; Make it printable escpr2: mov ah,conout int dos ret ESCPRT ENDP ; Set parity for character in Register AL dopar: push bx mov bx,portval mov bl,[bx].parflg ; get parity flag byte cmp bl,parnon ; No parity? je parret ; Just return and al,07FH ; Strip parity. Same as Space parity cmp bl,parspc ; Space parity? je parret ; e = yes, then we are done here cmp bl,parevn ; Even parity? jne dopar0 ; ne = no or al,al jpe parret ; pe = even parity now xor al,080H ; Make it even parity jmp short parret dopar0: cmp bl,parmrk ; Mark parity? jne dopar1 ; ne = no or al,080H ; Turn on the parity bit jmp short parret dopar1: cmp bl,parodd ; Odd parity? or al,al jpo parret ; Already odd, leave it xor al,080H ; Make it odd parity parret: pop bx ret cptchr proc near ; session capture routine, char in al push di mov di,capbp ; buffer pointer mov byte ptr [di],al inc capbp pop di dec caplft ; decrement chars remaining jg cptch1 ; more room, forget this part call cptdmp ; dump the info cptch1: ret cptchr endp cptdmp proc near ; empty the capture buffer push ax push bx push cx push dx mov bx,sloghnd ; get file handle cmp bx,0 ; is file open? jle cptdm1 ; le = no, skip it mov cx,cptsiz ; original buffer size sub cx,caplft ; minus number remaining jl cptdm2 ; means error jcxz cptdm1 ; z = nothing to do mov dx,offset capbuf ; the capture routine buffer mov ah,write2 ; write with filehandle int dos ; write out the block jc cptdm2 ; carry set means error mov capbp,offset capbuf mov caplft,cptsiz ; init buffer ptr & chrs left jmp short cptdm1 cptdm2: and targ.flgs,not capt ; so please stop capturing ; mov dx,offset erms23 ; tell user the bad news mcmsg erms23,cerms23 mov ah,prstr int dos cptdm1: pop dx pop cx pop bx pop ax ret cptdmp endp pktcpt proc near ; packet log routine, char in al push di mov di,pktbp mov [di],al ; store char in buffer inc pktbp ; move pointer to next free byte pop di dec pktlft ; decrement chars remaining jg pktcp1 ; more room, forget this part call pktdmp ; dump the info pktcp1: ret pktcpt endp pktdmp proc near ; empty the capture buffer push ax push bx push cx push dx mov bx,ploghnd ; get file handle cmp bx,0 ; is file open? jle cptdm1 ; le = no, skip it mov cx,cptsiz ; original buffer size sub cx,pktlft ; minus number remaining jl pktdm2 ; l means error jcxz pktdm1 ; z = nothing to do mov dx,offset pktbuf ; the capture routine buffer mov ah,write2 ; write with filehandle int dos ; write out the block jc pktdm2 ; carry set means error mov pktbp,offset pktbuf mov pktlft,cptsiz ; init buffer ptr & chrs left jmp short pktdm1 pktdm2: and targ.flgs,not capt ; so please stop capturing ; mov dx,offset erms24 ; tell user the bad news mcmsg erms24,cerms24 mov ah,prstr int dos call clscp4 ; close the packet log pktdm1: pop dx pop cx pop bx pop ax ret pktdmp endp ; CLOSE command clscpt proc near mov ah,cmkey mov dx,offset clotab ; close table ; mov bx,offset clohlp ; help mcmsgb clohlp,cclohlp call comnd jmp r nop mov tmp,bl mov ah,cmcfm call comnd jmp r mov bl,tmp test flags.capflg,0FFH ; are any kinds active? jz clscp1 ; z = no cmp bl,logpkt+logses+logtrn ; close all? je clscpi ; e = yes cmp bl,logpkt ; just packet? je clscp4 cmp bl,logses ; just session? je clscp6 cmp bl,logtrn ; just session? jne clscp1 jmp clscp8 clscp1: ; mov dx,offset erms22 ; say none active mcmsg erms22,cerms22 mov ah,prstr int dos jmp rskp ; CLSCPI called at Kermit exit CLSCPI: call clscp4 ; close packet log call clscp6 ; close session log call clscp8 ; close transaction log jmp rskp ; return success clscp4: push bx ; PACKET LOG mov bx,ploghnd ; packet log handle cmp bx,0 ; is it open? jle clscp5 ; e = no call pktdmp ; dump buffer mov ah,close2 int dos mov ah,prstr ; mov dx,offset clpktlog ; tell what we are doing mcmsg clpktlog,cclpktlog int dos clscp5: mov ploghnd,-1 ; say handle is invalid pop bx and flags.capflg,not logpkt ; say this log is closed ret clscp6: push bx ; SESSION LOG mov bx,sloghnd ; session log handle cmp bx,0 ; is it open? jle clscp7 ; e = no call cptdmp ; dump buffer mov ah,close2 int dos mov ah,prstr ; mov dx,offset clseslog ; tell what we are doing mcmsg clseslog,cclseslog int dos clscp7: mov sloghnd,-1 ; say handle is invalid pop bx and flags.capflg,not logses ; say this log is closed ret clscp8: push bx ; TRANSACTION LOG mov bx,tloghnd ; transaction log handle cmp bx,0 ; is it open? jle clscp9 ; e = no mov ah,close2 int dos mov ah,prstr ; mov dx,offset cltrnlog ; tell what we are doing mcmsg cltrnlog,ccltrnlog int dos clscp9: mov tloghnd,-1 ; say handle is invalid pop bx and flags.capflg,not logtrn ; say this log is closed ret clscpt endp ; worker: copy line from si to di, first removing trailing spaces, second ; parsing out curly braced strings, then third converting \{b##} in strings ; to binary numbers. Returns carry set if error; else carry clear, with byte ; count in cx. Braces are optional but must occur in pairs. ; Items which cannot be converted to legal numbers are copied verbatium ; to the output string (ex: \{c} is copied as \{c} but \{x0d} is hex 0dh). cnvlin proc near push ax push si ; source ptr push di ; destination ptr push es ; end of save regs push ds ; move ds into es pop es ; use datas segment for es:di call cnvstr ; trim trailing, parse curly braces xor cx,cx ; initialize returned byte count cnvln1: cmp byte ptr [si],0 ; at end of string? je cnvln2 ; e = yes, exit call katoi ; read char, convert ascii to binary cld stosb ; save the char inc cx ; and count it or ah,ah ; is returned number > 255? jz cnvln1 ; z = no, do more chars push ax stosb ; save high order byte next pop ax inc cx jmp short cnvln1 ; do more chars cnvln2: mov byte ptr [di],0 ; plant terminator clc ; clear c bit, success cnvlnx: pop es ; restore regs pop di ; destination ptr pop si ; source ptr pop ax ret cnvlin endp ; Convert string by first remove trailing spaces and then removing surrounding ; curly brace delimiter pair. Converts text in place. ; Enter with source ptr in si. ; Preserves all registers, uses byte tmp. 9 Oct 1987 [jrd] ; cnvstr proc near push ax push cx push dx push si ; save start of source string push di push es ; 1. Trim trailing spaces mov dx,si ; source address call strlen ; get current length to cx jcxz cnvst4 ; z = nothing there mov di,si ; set di to source address add di,cx ; start at end of string dec di ; ignore terminator mov al,spc ; scan while spaces push ds pop es ; set es to datas segment std ; search backward repe scasb ; scan off trailing spaces mov byte ptr [di+2],0 ; terminate string after last text cld mov di,si ; set destination address to source ; 2. Parse off curly brace delimiters cmp byte ptr [si],braceop ; opening brace? jne cnvst4 ; ne = no, ignore brace-matching code inc si ; skip opening brace mov dl,braceop ; opening brace (we count them up) mov dh,bracecl ; closing brace (we count them down) mov tmp,1 ; we are at brace level 1 cnvst1: cld ; search forward lodsb ; read a string char stosb ; store char (skips opening brace) cmp al,0 ; at end of string? je cnvst4 ; e = yes, we are done cmp al,dl ; an opening brace? jne cnvst2 ; ne = no inc tmp ; yes, increment brace level jmp short cnvst1 ; and continue scanning cnvst2: cmp al,dh ; closing brace? jne cnvst1 ; ne = no, continue scanning dec tmp ; yes, decrement brace level cmp byte ptr [si],0 ; have we just read the last char? jne cnvst3 ; no, continue scanning mov tmp,0 ; yes, this is the closing brace cnvst3: cmp tmp,0 ; at level 0? jne cnvst1 ; ne = no, #opening > #closing braces mov byte ptr [di-1],0 ; plant terminator on closing brace cnvst4: pop es ; recover original registers pop di pop si pop dx pop cx pop ax ret cnvstr endp ; Convert ascii strings of the form "\{bnnn}" to a binary word in ax. ; The braces are optional but must occur in pairs. Numeric base indicator "b" ; is O or o or X or x or D or d or missing, for octal, hex, or decimal (def). ; Enter with si pointing at "\". ; Returns binary value in ax with carry clear and si to right of "}" or at ; terminating non-numeric char if successful; otherwise, a failure, ; return carry set with si = entry value + 1 and first read char in al. katoi proc near cld lodsb ; get first char xor ah,ah ; clear high order field push cx ; save working reg push si ; save entry si+1 push bx push ax ; save read char KATOI1: cmp al,0 ; end of text? ENTRY POINT FOR ATOI je katoi1a ; e = yes, exit failure cmp al,'\' ; escape char? je katoi1b ; e = yes katoi1a:jmp katoix ; common jump point to exit failure katoi1b:lodsb ; get next char, maybe brace cmp al,0 ; premature end? je katoi1a ; e = yes, exit failure xor bx,bx ; no conv yet, assume no opening brace cmp al,braceop ; opening brace? jne katoi2 ; ne = no, have number or base mov bl,bracecl ; remember a closing brace is needed lodsb ; get number base, if any katoi2: xor cx,cx ; temporary place for binary value mov nbase,10 ; assume decimal numbers cmp al,0 ; premature end? je katoix ; e = yes, exit failure cmp al,'a' ; lower case? jb katoi3 ; b = no cmp al,'z' ; in range of lower case? ja katoi3 ; a = no and al,5fh ; map to upper case katoi3: cmp al,'O' ; octal? jne katoi4 ; ne = no mov nbase,8 ; set number base jmp short katoi6 katoi4: cmp al,'X' ; hex? jne katoi5 ; ne = no mov nbase,16 jmp short katoi6 katoi5: cmp al,'D' ; decimal? jne katoi7 ; ne = no base char, assume decimal mov nbase,10 katoi6: lodsb ; get a digit katoi7: cmp al,0 ; premature end? je katoi8a ; e = yes, use it as a normal end cmp al,bl ; closing brace? je katoi9 ; e = yes call cnvdig ; convert ascii to binary digit jc katoi8 ; c = cannot convert inc bh ; say we did a successful conversion xor ah,ah ; clear high order value push ax ; save this byte's value xchg ax,cx ; put binary summation in ax mul nbase ; scale up current sum xchg ax,cx ; put binary back in cx pop ax ; recover binary digit add cx,ax ; form running sum jc katoix ; c = overflow error, exit cmp dx,0 ; overflow? jne katoix ; ne = yes, exit with error jmp short katoi6 ; get more katoi8: cmp bl,0 ; closing brace needed? jne katoix ; ne = yes, but not found katoi8a:dec si ; backup to reread terminator katoi9: cmp bh,0 ; did we do any conversion? je katoix ; e = no, exit failure pop ax ; throw away old saved ax pop bx ; restore bx pop ax ; throw away starting si, keep current mov ax,cx ; return final value in ax pop cx ; restore old cx clc ; clear carry for success ret katoix: pop ax ; restore first read al pop bx pop si ; restore start value + 1 pop cx ; restore old cx stc ; set carry for failure ret katoi endp cnvdig proc near ; convert ascii code in al to binary push cx ; return carry set if cannot push es ; nbase has numeric base push di push ax cmp al,'a' ; lower case? jb cnvdig1 ; b = no cmp al,'f' ; highest hex digit ja cnvdigx ; a = illegal symbol sub al,'a'-'A' ; convert 'a' to 'f' to upper case cnvdig1:mov di,offset numset ; set of legal number symbols mov cx,nbase ; number of legal symbols in this base cmp cx,cx ; preset z flag push ds pop es ; point es at data segment cld ; scan forward repne scasb ; find character in set jne cnvdigx ; ne = not found cnvdig2:inc cx ; offset auto-dec of repne scasb above sub cx,nbase ; counted off minus length neg cx ; two's complement = final value pop ax ; saved ax mov ax,cx ; return binary in al clc ; c clear for success jmp short cnvdixx ; exit cnvdigx:stc ; c set for failure pop ax cnvdixx:pop di pop es pop cx ret cnvdig endp decout proc near ; display decimal number in ax push ax push cx push dx mov cx,10 ; set the numeric base call valout ; convert and output value pop dx pop cx pop ax ret decout endp valout proc near ; output number in ax using base in cx ; corrupts ax and dx xor dx,dx ; clear high word of numerator div cx ; (ax / cx), remainder = dx, quotient = ax push dx ; save remainder for outputting later or ax,ax ; any quotient left? jz valout1 ; z = no call valout ; yes, recurse valout1:pop dx ; get remainder add dl,'0' ; make digit printable cmp dl,'9' ; above 9? jbe valout2 ; be = no add dl,'A'-1-'9' ; use 'A'--'F' for values above 9 valout2:mov ah,conout int dos ret valout endp ; Convert input in buffer pointed to by SI to real number which is returned ; in AX. Enter with string size in AH. ; Return on failure, return skip on success. Revised by [jrd] ATOI PROC NEAR mov bx,0 ; high order of this stays 0 mov tmp,0 ; No input yet mov cl,ah ; Number of chars of input mov ch,0 ; size of string mov ax,0 ; init sum cld atoi0: jcxz atoi4 ; Fail on no input lodsb ; get an input char dec cx ; count number remaining cmp al,' ' ; leading space? je atoi0 ; e = yes, skip it cmp al,',' ; comma separator? je atoi0 ; e = yes, skip it dec si ; back up source pointer for reread below inc cx ; and readjust byte counter mov ax,0 ; clear sum atoi1: push ax ; save sum lodsb ; read a byte into al mov bl,al ; put it into bl pop ax ; regain sum cmp bl,'9' ; check range for '0' to '9' ja atoi2 ; above '9' cmp bl,'0' jb atoi2 ; below '0' sub bl,'0' ; take away ascii bias mul ten ; sum * 10. dx = high, ax = low add ax,bx ; add current value mov tmp,1 ; say have sum being computed loop atoi1 inc si ; inc for dec below atoi2: dec si ; point at terminator cmp tmp,0 ; were any digits discovered? je atoi4 ; e = no, fail atoi3: jmp rskp ; success exit, sum is in ax atoi4: ; mov dx,offset erms25 ; Input must be numeric mcmsg erms25,cerms25 ret ATOI ENDP ; Jumping to this location is like retskp. It assumes the instruction ; after the call is a jmp addr. RSKP PROC NEAR pop bp add bp,3 push bp ret RSKP ENDP ; Jumping here is the same as a ret R PROC NEAR ret R ENDP code ends end